Skip to content

Fix CPPCheck issues of type style::functionConst #104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Merged
merged 4 commits into from
Mar 6, 2025
Merged

Fix CPPCheck issues of type style::functionConst #104

merged 4 commits into from
Mar 6, 2025

Conversation

eljonny
Copy link
Owner

@eljonny eljonny commented Mar 6, 2025

Closes #29.

@eljonny eljonny added static-analysis An issue related to a static analysis result test-case Relating to TestCPP TestCase test-suite Relating to TestCPP TestSuite test-utils Related to TestCPP util functions and TestCPPUtil labels Mar 6, 2025
@eljonny eljonny added this to the 0.3-release milestone Mar 6, 2025
@eljonny eljonny self-assigned this Mar 6, 2025
@codecov Codecov
Copy link

codecov bot commented Mar 6, 2025 •
edited
Loading

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 87.52%. Comparing base (3b9e337) to head (819bd47).
Report is 4 commits behind head on main.

✅ All tests successful. No failed tests found.

Additional details and impacted files 
@@           Coverage Diff           @@
##             main     #104   +/-   ##
=======================================
  Coverage   87.52%   87.52%           
=======================================
  Files          10       10           
  Lines         489      489           
  Branches       61       61           
=======================================
  Hits          428      428           
  Misses         52       52           
  Partials        9        9

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

@github-actions GitHub Actions
Copy link

github-actions bot commented Mar 6, 2025 •
edited
Loading

⚡ Static analysis result ⚡

🔴 cppcheck found 5 issues! Click here to see details.

TestCPP/src/TestCPPTestCase.cpp

Lines 114 to 119 in 819bd47

TestCase::TestCase (TestObjName&& name,
function<void()> testFn,
bool msg,
bool captureOut, bool captureLog,
bool captureErr,
TestCase::TestCaseOutCompareOptions opt) 

!Line: 114 - style: inconclusive: Function 'TestCase' argument 1 names different: declaration 'testName' definition 'name'. [funcArgNamesDifferent]

!Line: 132 - note: Function 'TestCase' argument 1 names different: declaration 'testName' definition 'name'.
!Line: 114 - note: Function 'TestCase' argument 1 names different: declaration 'testName' definition 'name'.

TestCPP/src/TestCPPTestCase.cpp

Lines 115 to 120 in 819bd47

function<void()> testFn,
bool msg,
bool captureOut, bool captureLog,
bool captureErr,
TestCase::TestCaseOutCompareOptions opt)
{ 

!Line: 115 - style: inconclusive: Function 'TestCase' argument 2 names different: declaration 'test' definition 'testFn'. [funcArgNamesDifferent]

!Line: 133 - note: Function 'TestCase' argument 2 names different: declaration 'test' definition 'testFn'.
!Line: 115 - note: Function 'TestCase' argument 2 names different: declaration 'test' definition 'testFn'.

TestCPP/src/TestCPPTestCase.cpp

Lines 116 to 121 in 819bd47

bool msg,
bool captureOut, bool captureLog,
bool captureErr,
TestCase::TestCaseOutCompareOptions opt)
{
this->notifyTestPassed = msg; 

!Line: 116 - style: inconclusive: Function 'TestCase' argument 3 names different: declaration 'testPassedMessage' definition 'msg'. [funcArgNamesDifferent]

!Line: 134 - note: Function 'TestCase' argument 3 names different: declaration 'testPassedMessage' definition 'msg'.
!Line: 116 - note: Function 'TestCase' argument 3 names different: declaration 'testPassedMessage' definition 'msg'.

TestCPP/src/TestCPPTestCase.cpp

Lines 306 to 311 in 819bd47

void TestCase::logTestFailure (const string& reason) {
unique_ptr<ostream> logStream = nullptr;
if (this->clogOriginal.get() != nullptr) {
logStream = unique_ptr<ostream>(
new ostream(this->clogOriginal.get().get()) 

!Line: 306 - style: inconclusive: Function 'logTestFailure' argument 1 names different: declaration 'failureMessage' definition 'reason'. [funcArgNamesDifferent]

!Line: 299 - note: Function 'logTestFailure' argument 1 names different: declaration 'failureMessage' definition 'reason'.
!Line: 306 - note: Function 'logTestFailure' argument 1 names different: declaration 'failureMessage' definition 'reason'.

TestCPP/src/TestCPPTestCase.cpp

Lines 373 to 378 in 819bd47

void TestCase::setNotifyPassed (bool notify) {
this->notifyTestPassed = notify;
}
void TestCase::captureStdout () {
if (TestCase::stdoutCaptureCasesConstructed == 

!Line: 373 - style: inconclusive: Function 'setNotifyPassed' argument 1 names different: declaration 'shouldNotify' definition 'notify'. [funcArgNamesDifferent]

!Line: 180 - note: Function 'setNotifyPassed' argument 1 names different: declaration 'shouldNotify' definition 'notify'.
!Line: 373 - note: Function 'setNotifyPassed' argument 1 names different: declaration 'shouldNotify' definition 'notify'.
🔴 clang-tidy found 193 issues! Click here to see details.

TestCPP/src/TestCPPExceptions.cpp

Lines 28 to 33 in 819bd47

#include <iostream>
#include "internal/TestCPPExceptions.h"
#ifdef TESTCPP_STACKTRACE_ENABLED
#include <boost/stacktrace.hpp> 

!Line: 28 - error: included header iostream is not used directly [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 37 to 42 in 819bd47

using std::string;
using std::runtime_error;
namespace TestCPP {
TestCPPException::TestCPPException (const char * msg) : 

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 38 to 43 in 819bd47

using std::runtime_error;
namespace TestCPP {
TestCPPException::TestCPPException (const char * msg) :
runtime_error(msg) 

!Line: 38 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in 819bd47

TestCPPException(std::move(msg))
{
#ifdef TESTCPP_STACKTRACE_ENABLED
clog << boost::stacktrace::stacktrace();
#endif
} 

!Line: 66 - error: std::move of the const variable 'msg' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 49 - note: consider changing the 1st parameter of 'TestCPPException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in 819bd47

TestCPPException(std::move(msg))
{
#ifdef TESTCPP_STACKTRACE_ENABLED
clog << boost::stacktrace::stacktrace();
#endif
} 

!Line: 66 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPCommon.h

Lines 88 to 93 in 819bd47

static constexpr const char * SP = " ";
static constexpr const char * START_RUN =
"Starting run of test ";
static constexpr const char * SUITE = "Suite ";
static constexpr const char * SUITE_TESTS_PASSED =
" suite tests passed!"; 

!Line: 88 - error: variable name 'SP' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 73 to 78 in 819bd47

TestObjName (const char* name);
/**
* @brief Get the encapsulated name for the TestCPP object that
* holds this object.
* @return The name of the TestCPP object that this object 

!Line: 73 - error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 81 to 86 in 819bd47

const string& getName () const;
/**
* @brief Output the test object name to the specified stream.
* @param s The stream to output to.
* @param tcName The test object name object. 

!Line: 81 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 89 to 94 in 819bd47

friend std::ostream& operator<< (
std::ostream& s,
const TestObjName& tcName
);
private: 

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 90 to 95 in 819bd47

std::ostream& s,
const TestObjName& tcName
);
private:
string testCaseName; 

!Line: 90 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 106 to 111 in 819bd47

template <class T> class no_destroy {
alignas(T) unsigned char data[sizeof(T)];
public:
template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
}; 

!Line: 106 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 107 to 112 in 819bd47

alignas(T) unsigned char data[sizeof(T)];
public:
template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
}; 

!Line: 107 - error: do not declare C-style arrays, use 'std::array' instead [cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in 819bd47

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 109 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in 819bd47

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 109 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in 819bd47

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 109 - error: parameter name 'ts' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in 819bd47

T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug
* logging is enabled. 

!Line: 110 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in 819bd47

T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug
* logging is enabled. 

!Line: 110 - error: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 136 to 141 in 819bd47

bool stringContains (const string& source,
const string& contains);
/**
* @brief Safely converts unsigned integer values to signed.
* @param toCast The unsigned value to convert. 

!Line: 136 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 144 to 148 in 819bd47

int unsignedToSigned(unsigned toCast);
}
}
#endif 

!Line: 144 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 51 to 56 in 819bd47

if (name) {
this->testCaseName = name;
}
else {
throw TestCPPException(TCPPStr::NVTN);
} 

!Line: 51 - error: implicit conversion 'const char *' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 59 to 64 in 819bd47

const string& TestObjName::getName () const {
return this->testCaseName;
}
std::ostream& operator<< (
std::ostream& s, 

!Line: 59 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 63 to 68 in 819bd47

std::ostream& operator<< (
std::ostream& s,
const TestObjName& tcName
)
{
s << tcName.getName(); 

!Line: 63 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 64 to 69 in 819bd47

std::ostream& s,
const TestObjName& tcName
)
{
s << tcName.getName();
return s; 

!Line: 64 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 78 to 83 in 819bd47

clog << endl;
}
#endif
}
bool stringContains(const string& source, 

!Line: 78 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 83 to 88 in 819bd47

bool stringContains(const string& source,
const string& contains)
{
return source.find(contains) != string::npos;
} 

!Line: 83 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 89 to 94 in 819bd47

int unsignedToSigned(unsigned toCast) {
if (toCast <= INT_MAX) {
return static_cast<int>(toCast);
}
if (toCast >= static_cast<unsigned>(INT_MIN)) { 

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 84 to 89 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 84 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 85 to 90 in 819bd47

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that something is not equivalent to something 

!Line: 85 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 110 to 115 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 110 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 111 to 116 in 819bd47

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that a pointer is null. 

!Line: 111 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 131 to 136 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 131 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 132 to 137 in 819bd47

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that a pointer is non-null. 

!Line: 132 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 152 to 157 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 152 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 153 to 158 in 819bd47

throw TestFailedException(std::move(err));
}
}
/**
* @brief Verify that a function throws something. 

!Line: 153 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in 819bd47

static const string logTestFailure(
T1 expectationValue, T2 actual,
const string& assertionTypeMessage,
const string& failureMessage,
const bool logValues
) 

!Line: 243 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in 819bd47

static const string logTestFailure(
T1 expectationValue, T2 actual,
const string& assertionTypeMessage,
const string& failureMessage,
const bool logValues
) 

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 252 to 257 in 819bd47

err << assertionTypeMessage << endl;
err << failureMessage << endl;
if (logValues) {
err << "Expectation value: <" << expectationValue << ">"
<< endl; 

!Line: 252 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 253 to 258 in 819bd47

err << failureMessage << endl;
if (logValues) {
err << "Expectation value: <" << expectationValue << ">"
<< endl;
err << "Actual: <" << actual << ">" << endl; 

!Line: 253 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in 819bd47

static const string checkEquals(
T1 expected, T2 actual,
const string& failureMessage
)
{
if (expected != actual) { 

!Line: 265 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in 819bd47

static const string checkEquals(
T1 expected, T2 actual,
const string& failureMessage
)
{
if (expected != actual) { 

!Line: 265 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in 819bd47

static const string checkNotEquals(
T1 shouldNotBe, T2 actual,
const string& failureMessage
)
{
if (shouldNotBe == actual) { 

!Line: 282 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in 819bd47

static const string checkNotEquals(
T1 shouldNotBe, T2 actual,
const string& failureMessage
)
{
if (shouldNotBe == actual) { 

!Line: 282 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in 819bd47

static const string checkNull(
T ptr,
const string& failureMessage
)
{
bool null = ptr == nullptr; 

!Line: 299 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in 819bd47

static const string checkNull(
T ptr,
const string& failureMessage
)
{
bool null = ptr == nullptr; 

!Line: 299 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in 819bd47

static const string checkNotNull(
T ptr,
const string& failureMessage
)
{
bool notNull = ptr != nullptr; 

!Line: 318 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in 819bd47

static const string checkNotNull(
T ptr,
const string& failureMessage
)
{
bool notNull = ptr != nullptr; 

!Line: 318 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 387 to 392 in 819bd47

const string TestCPP::Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
);
template<> 

!Line: 387 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 393 to 398 in 819bd47

const string TestCPP::Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
);
#endif 

!Line: 393 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 30 to 35 in 819bd47

using std::clog;
using std::current_exception;
using std::endl;
using std::exception;
using std::exception_ptr;
using std::function; 

!Line: 30 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 31 to 36 in 819bd47

using std::current_exception;
using std::endl;
using std::exception;
using std::exception_ptr;
using std::function;
using std::rethrow_exception; 

!Line: 31 - error: no header providing "std::current_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 33 to 38 in 819bd47

using std::exception;
using std::exception_ptr;
using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream; 

!Line: 33 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 34 to 39 in 819bd47

using std::exception_ptr;
using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream; 

!Line: 34 - error: no header providing "std::__exception_ptr::exception_ptr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 35 to 40 in 819bd47

using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream;
namespace TestCPP { 

!Line: 35 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 36 to 41 in 819bd47

using std::rethrow_exception;
using std::string;
using std::stringstream;
namespace TestCPP { 

!Line: 36 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 37 to 42 in 819bd47

using std::string;
using std::stringstream;
namespace TestCPP {
template<> 

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 38 to 43 in 819bd47

using std::stringstream;
namespace TestCPP {
template<>
const string Assertions::checkEquals<const char*, const char*>( 

!Line: 38 - error: no header providing "std::stringstream" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in 819bd47

const string Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
)
{
if (strcmp(expected, actual)) { 

!Line: 43 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in 819bd47

const string Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
)
{
if (strcmp(expected, actual)) { 

!Line: 43 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in 819bd47

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: function 'strcmp' is called without explicitly comparing result [bugprone-suspicious-string-compare,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in 819bd47

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: no header providing "strcmp" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in 819bd47

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in 819bd47

const string Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
)
{
if (!strcmp(shouldNotBe, actual)) { 

!Line: 60 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in 819bd47

const string Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
)
{
if (!strcmp(shouldNotBe, actual)) { 

!Line: 60 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 65 to 70 in 819bd47

if (!strcmp(shouldNotBe, actual)) {
return logTestFailure(
shouldNotBe, actual,
nonequivalenceAssertionMessage,
failureMessage,
true 

!Line: 65 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
template<> 

!Line: 83 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
template<> 

!Line: 83 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in 819bd47

throw TestFailedException(std::move(err));
}
}
template<>
void Assertions::assertNotEquals<const char*, const char*>( 

!Line: 84 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in 819bd47

throw TestFailedException(std::move(err));
}
}
template<>
void Assertions::assertNotEquals<const char*, const char*>( 

!Line: 84 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows ( 

!Line: 96 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows ( 

!Line: 96 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 97 to 102 in 819bd47

throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows (
function<void()> shouldThrow, 

!Line: 97 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 102 to 107 in 819bd47

function<void()> shouldThrow,
const string& failureMessage
)
{
try {
shouldThrow(); 

!Line: 102 - error: the parameter 'shouldThrow' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 110 to 115 in 819bd47

exception_ptr eptr = current_exception();
if (eptr) {
try {
rethrow_exception(eptr);
} 

!Line: 110 - error: variable 'eptr' of type 'exception_ptr' can be declared 'const' [misc-const-correctness,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 119 to 124 in 819bd47

<< endl;
}
}
else {
clog << "Something was thrown, not sure what." << endl
<< "This satisfies the assertion, so no failure is" 

!Line: 119 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 123 to 128 in 819bd47

clog << "Something was thrown, not sure what." << endl
<< "This satisfies the assertion, so no failure is"
<< " present. "
<< TestFailedException("Unknown thrown object").
what();
} 

!Line: 123 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 133 to 138 in 819bd47

throw TestFailedException(std::move(failureMessage));
}
void Assertions::assertNoThrows (
function<void()> shouldNotThrow,
const string& failureMessage 

!Line: 133 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 137 to 142 in 819bd47

function<void()> shouldNotThrow,
const string& failureMessage
)
{
try {
shouldNotThrow(); 

!Line: 137 - error: the parameter 'shouldNotThrow' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 145 to 150 in 819bd47

throw TestFailedException(std::move(failureMessage));
}
}
void Assertions::assertTrue (
bool condition, 

!Line: 145 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 164 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 164 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 165 to 170 in 819bd47

throw TestFailedException(std::move(err));
}
}
}
void Assertions::assertFalse ( 

!Line: 165 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 185 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in 819bd47

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 185 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 186 to 191 in 819bd47

throw TestFailedException(std::move(err));
}
}
}
[[noreturn]] void Assertions::fail(string failureMessage) { 

!Line: 186 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 191 to 194 in 819bd47

[[noreturn]] void Assertions::fail(string failureMessage) {
throw TestFailedException(std::move(failureMessage));
}
} 

!Line: 191 - error: the parameter 'failureMessage' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 192 to 194 in 819bd47

throw TestFailedException(std::move(failureMessage));
}
} 

!Line: 192 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 92 to 97 in 819bd47

enum TestCaseOutCompareOptions {
CONTAINS,
EXACT
};
/** 

!Line: 92 - error: enum 'TestCaseOutCompareOptions' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 131 to 136 in 819bd47

TestCase (
TestObjName&& testName,
function<void()> test,
bool testPassedMessage = true,
bool captureOut = false,
bool captureLog = false, 

!Line: 131 - error: function 'TestCPP::TestCase::TestCase' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name,-warnings-as-errors]

!Line: 114 - note: the definition seen here
!Line: 131 - note: differing parameters are named here: ('testPassedMessage'), in definition: ('msg')

TestCPP/include/internal/TestCPPTestCase.h

Lines 146 to 151 in 819bd47

TestCase (const TestCase& o);
/**
* @brief Construct a TestCase by moving all data from another
* TestCase.
* @param o Move everything from this TestCase into the new one. 

!Line: 146 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 153 to 158 in 819bd47

TestCase (TestCase&& o) noexcept;
/**
* @brief Copy a TestCase into another TestCase.
* @param rhs The test case to copy from.
* @return A reference to the new TestCase copy. 

!Line: 153 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 160 to 165 in 819bd47

TestCase& operator= (const TestCase& rhs);
/**
* @brief Move a TestCase into another TestCase.
* @param rhs Move everything from this TestCase into the new
* one. 

!Line: 160 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 169 to 174 in 819bd47

TestCase& operator= (TestCase&& rhs) noexcept;
/**
* @brief Destroy a TestCase object.
*/
~TestCase (); 

!Line: 169 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 224 to 229 in 819bd47

bool checkStdout (const string& against);
/**
* @brief Check the argument against what is captured from
* std::clog using the configured comparison mode.
* @param against The value to check the captured output against 

!Line: 224 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 233 to 238 in 819bd47

bool checkLog (const string& against);
/**
* @brief Check the argument against what is captured from
* stderr using the configured comparison mode.
* @param against The value to check the captured output against 

!Line: 233 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 243 to 248 in 819bd47

bool checkStderr (const string& against);
/**
* @brief Run the test case.
* @return True if the test ran successfully, false otherwise.
*/ 

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 249 to 254 in 819bd47

bool go ();
/**
* @brief Returns the duration of the last run in nanoseconds.
* @return The duration of the last run of this TestCase in
* nanoseconds. 

!Line: 249 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 256 to 261 in 819bd47

long long getLastRuntime () const;
private:
bool notifyTestPassed = false;
bool pass = false;
bool stdoutCaptured = false; 

!Line: 256 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 299 to 304 in 819bd47

void logTestFailure (const string& failureMessage);
/**
* @brief Internal test run controller.
*/
void runTest ();
/** 

!Line: 299 - error: function 'TestCPP::TestCase::logTestFailure' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name,-warnings-as-errors]

!Line: 306 - note: the definition seen here
!Line: 299 - note: differing parameters are named here: ('failureMessage'), in definition: ('reason')

TestCPP/include/internal/TestCPPTestCase.h

Lines 315 to 320 in 819bd47

bool checkOutput (const string& source, const string& against);
static atomic_int stdoutCaptureCasesConstructed;
static atomic_int logCaptureCasesConstructed;
static atomic_int stderrCaptureCasesConstructed;
static atomic_int stdoutCaptureCasesDestroyed; 

!Line: 315 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 345 to 350 in 819bd47

static nanoseconds duration (F func, Args&&... args)
{
auto start = system_clock::now();
func(forward<Args>(args)...);
return duration_cast<nanoseconds>(
system_clock::now() - start 

!Line: 345 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 345 to 350 in 819bd47

static nanoseconds duration (F func, Args&&... args)
{
auto start = system_clock::now();
func(forward<Args>(args)...);
return duration_cast<nanoseconds>(
system_clock::now() - start 

!Line: 345 - error: the parameter 'func' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in 819bd47

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 109 - error: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 45 to 50 in 819bd47

using std::cerr;
using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed; 

!Line: 45 - error: no header providing "std::cerr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 46 to 51 in 819bd47

using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function; 

!Line: 46 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 47 to 52 in 819bd47

using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument; 

!Line: 47 - error: no header providing "std::cout" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 49 to 54 in 819bd47

using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error; 

!Line: 49 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 50 to 55 in 819bd47

using std::fixed;
using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision; 

!Line: 50 - error: no header providing "std::fixed" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 51 to 56 in 819bd47

using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string; 

!Line: 51 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in 819bd47

using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 52 - error: no header providing "std::invalid_argument" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in 819bd47

using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 52 - error: using decl 'invalid_argument' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 52 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in 819bd47

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 53 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in 819bd47

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 53 - error: using decl 'rethrow_exception' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 53 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in 819bd47

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 54 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in 819bd47

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 54 - error: using decl 'runtime_error' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 54 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 56 to 61 in 819bd47

using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings; 

!Line: 56 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in 819bd47

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 57 - error: no header providing "std::tuple" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in 819bd47

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 57 - error: using decl 'tuple' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 57 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 64 to 69 in 819bd47

atomic_int TestCase::stdoutCaptureCasesConstructed;
atomic_int TestCase::logCaptureCasesConstructed;
atomic_int TestCase::stderrCaptureCasesConstructed;
atomic_int TestCase::stdoutCaptureCasesDestroyed;
atomic_int TestCase::logCaptureCasesDestroyed;
atomic_int TestCase::stderrCaptureCasesDestroyed; 

!Line: 64 - error: no header providing "atomic_int" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 72 to 77 in 819bd47

TestCase::stdoutBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 72 - error: initialization of 'stdoutBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 79 to 84 in 819bd47

TestCase::clogBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 79 - error: initialization of 'clogBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 86 to 91 in 819bd47

TestCase::stderrBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 86 - error: initialization of 'stderrBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 93 to 98 in 819bd47

TestCase::stdoutOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 93 - error: initialization of 'stdoutOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 100 to 105 in 819bd47

TestCase::clogOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 100 - error: initialization of 'clogOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 107 to 112 in 819bd47

TestCase::stderrOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 107 - error: initialization of 'stderrOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 114 to 119 in 819bd47

TestCase::TestCase (TestObjName&& name,
function<void()> testFn,
bool msg,
bool captureOut, bool captureLog,
bool captureErr,
TestCase::TestCaseOutCompareOptions opt) 

!Line: 114 - error: rvalue reference parameter 'name' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 121 to 126 in 819bd47

this->notifyTestPassed = msg;
this->test = testFn;
this->testName = name;
if (captureOut) { 

!Line: 121 - error: 'notifyTestPassed' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 122 to 127 in 819bd47

this->test = testFn;
this->testName = name;
if (captureOut) {
captureStdout(); 

!Line: 122 - error: 'test' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 122 to 127 in 819bd47

this->test = testFn;
this->testName = name;
if (captureOut) {
captureStdout(); 

!Line: 122 - error: parameter 'testFn' is passed by value and only copied once; consider moving it to avoid unnecessary copies [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 124 to 129 in 819bd47

this->testName = name;
if (captureOut) {
captureStdout();
}
if (captureLog) { 

!Line: 124 - error: 'testName' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 145 to 150 in 819bd47

TestCase::TestCase (const TestCase& o) {
this->outCompareOption(o.option);
this->setNotifyPassed(o.notifyTestPassed);
this->pass = o.pass;
this->lastRunTime = o.lastRunTime; 

!Line: 145 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 149 to 154 in 819bd47

this->pass = o.pass;
this->lastRunTime = o.lastRunTime;
this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured; 

!Line: 149 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 150 to 155 in 819bd47

this->lastRunTime = o.lastRunTime;
this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured; 

!Line: 150 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 152 to 157 in 819bd47

this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 152 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 153 to 158 in 819bd47

this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 153 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 154 to 159 in 819bd47

this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 154 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 170 to 175 in 819bd47

TestCase::TestCase (TestCase&& o) noexcept {
this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass); 

!Line: 170 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in 819bd47

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: 'option' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in 819bd47

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in 819bd47

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in 819bd47

this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured); 

!Line: 173 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in 819bd47

this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured); 

!Line: 173 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 175 to 180 in 819bd47

this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 175 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 175 to 180 in 819bd47

this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 175 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in 819bd47

this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 176 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in 819bd47

this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 176 - error: std::move of the expression of the trivially-copyable type 'long long' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in 819bd47

this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 176 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 178 to 183 in 819bd47

this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 178 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 178 to 183 in 819bd47

this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 178 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 179 to 184 in 819bd47

this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 179 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 179 to 184 in 819bd47

this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 179 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 180 to 185 in 819bd47

this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 180 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 180 to 185 in 819bd47

this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 180 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 192 to 197 in 819bd47

this->testName = std::move(o.testName);
this->test = std::move(o.test);
}
TestCase::~TestCase () {
if (TestCase::stdoutBuffer.get() != nullptr) 

!Line: 192 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 193 to 198 in 819bd47

this->test = std::move(o.test);
}
TestCase::~TestCase () {
if (TestCase::stdoutBuffer.get() != nullptr)
{ 

!Line: 193 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 203 to 208 in 819bd47

delete TestCase::stdoutBuffer.get().get();
TestCase::stdoutBuffer.get() = nullptr;
}
TestCase::stdoutCaptureCasesDestroyed += 1;
} 

!Line: 203 - error: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory,-warnings-as-errors]

!Line: 71 - note: variable declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 215 to 220 in 819bd47

delete TestCase::clogBuffer.get().get();
TestCase::clogBuffer.get() = nullptr;
}
TestCase::logCaptureCasesDestroyed += 1;
} 

!Line: 215 - error: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory,-warnings-as-errors]

!Line: 78 - note: variable declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 227 to 232 in 819bd47

delete TestCase::stderrBuffer.get().get();
TestCase::stderrBuffer.get() = nullptr;
}
TestCase::stderrCaptureCasesDestroyed += 1;
} 

!Line: 227 - error: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory,-warnings-as-errors]

!Line: 85 - note: variable declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 235 to 240 in 819bd47

TestCase& TestCase::operator= (const TestCase& rhs) {
this->outCompareOption(rhs.option);
this->setNotifyPassed(rhs.notifyTestPassed);
this->pass = rhs.pass;
this->lastRunTime = rhs.lastRunTime; 

!Line: 235 - error: operator=() does not handle self-assignment properly [cert-oop54-cpp,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 235 to 240 in 819bd47

TestCase& TestCase::operator= (const TestCase& rhs) {
this->outCompareOption(rhs.option);
this->setNotifyPassed(rhs.notifyTestPassed);
this->pass = rhs.pass;
this->lastRunTime = rhs.lastRunTime; 

!Line: 235 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 262 to 267 in 819bd47

TestCase& TestCase::operator= (TestCase&& rhs) noexcept {
this->option = std::move(rhs.option);
this->setNotifyPassed(std::move(rhs.notifyTestPassed));
this->pass = std::move(rhs.pass); 

!Line: 262 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 263 to 268 in 819bd47

this->option = std::move(rhs.option);
this->setNotifyPassed(std::move(rhs.notifyTestPassed));
this->pass = std::move(rhs.pass);
this->lastRunTime = std::move(rhs.lastRunTime); 

!Line: 263 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 265 to 270 in 819bd47

this->setNotifyPassed(std::move(rhs.notifyTestPassed));
this->pass = std::move(rhs.pass);
this->lastRunTime = std::move(rhs.lastRunTime);
this->stdoutCaptured = std::move(rhs.stdoutCaptured); 

!Line: 265 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 267 to 272 in 819bd47

this->pass = std::move(rhs.pass);
this->lastRunTime = std::move(rhs.lastRunTime);
this->stdoutCaptured = std::move(rhs.stdoutCaptured);
this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured); 

!Line: 267 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 268 to 273 in 819bd47

this->lastRunTime = std::move(rhs.lastRunTime);
this->stdoutCaptured = std::move(rhs.stdoutCaptured);
this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured); 

!Line: 268 - error: std::move of the expression of the trivially-copyable type 'long long' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 270 to 275 in 819bd47

this->stdoutCaptured = std::move(rhs.stdoutCaptured);
this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 270 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 271 to 276 in 819bd47

this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 271 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 272 to 277 in 819bd47

this->stderrCaptured = std::move(rhs.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 272 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 290 to 295 in 819bd47

long long TestCase::getLastRuntime () const {
return this->lastRunTime;
}
void TestCase::logFailure(ostream& out, const string& reason) const {
out << fixed; 

!Line: 290 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 302 to 307 in 819bd47

<< endl;
out << TCPPStr::REASON_ << reason << endl;
}
void TestCase::logTestFailure (const string& reason) {
unique_ptr<ostream> logStream = nullptr; 

!Line: 302 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 303 to 308 in 819bd47

out << TCPPStr::REASON_ << reason << endl;
}
void TestCase::logTestFailure (const string& reason) {
unique_ptr<ostream> logStream = nullptr; 

!Line: 303 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 309 to 314 in 819bd47

if (this->clogOriginal.get() != nullptr) {
logStream = unique_ptr<ostream>(
new ostream(this->clogOriginal.get().get())
);
}
else { 

!Line: 309 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 311 to 316 in 819bd47

new ostream(this->clogOriginal.get().get())
);
}
else {
logStream = unique_ptr<ostream>(&clog);
} 

!Line: 311 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 320 to 325 in 819bd47

if (this->clogOriginal.get() != nullptr) {
logStream->flush();
// If someone is looking for something in the message,
// and it's captured, make sure it's there.
logFailure(clog, reason); 

!Line: 320 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 328 to 333 in 819bd47

logStream.release();
logStream.reset();
}
void TestCase::runTest () {
clog << TCPPStr::START_RUN << this->testName << endl; 

!Line: 328 - error: the value returned by this function should not be disregarded; neglecting it may lead to errors [bugprone-unused-return-value,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 333 to 338 in 819bd47

clog << TCPPStr::START_RUN << this->testName << endl;
this->lastRunTime = duration(this->test).count();
if (this->notifyTestPassed) {
clog << fixed;
clog << setprecision(TCPPNum::TIME_PRECISION);
clog << TCPPStr::TEST << this->testName << TCPPStr::PASS 

!Line: 333 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 343 to 348 in 819bd47

<< endl;
}
this->pass = true;
}
bool TestCase::go () { 

!Line: 343 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 348 to 353 in 819bd47

bool TestCase::go () {
try {
runTest();
return true;
}
catch(const char * errorMessage) { 

!Line: 348 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 377 to 382 in 819bd47

void TestCase::captureStdout () {
if (TestCase::stdoutCaptureCasesConstructed ==
TestCase::stdoutCaptureCasesDestroyed)
{
TestCase::stdoutCaptureCasesConstructed += 1;
TestCase::stdoutBuffer = 

!Line: 377 - error: method 'captureStdout' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 401 to 406 in 819bd47

void TestCase::captureClog () {
if (TestCase::logCaptureCasesConstructed ==
TestCase::logCaptureCasesDestroyed)
{
TestCase::logCaptureCasesConstructed += 1;
TestCase::clogBuffer = 

!Line: 401 - error: method 'captureClog' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 425 to 430 in 819bd47

void TestCase::captureStdErr () {
if (TestCase::stderrCaptureCasesConstructed ==
TestCase::stderrCaptureCasesDestroyed)
{
TestCase::stderrCaptureCasesConstructed += 1;
TestCase::stderrBuffer = 

!Line: 425 - error: method 'captureStdErr' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 481 to 486 in 819bd47

bool TestCase::checkStdout (const string& against) {
return checkOutput(TestCase::stdoutBuffer.get()->str(),
against);
}
bool TestCase::checkLog (const string& against) { 

!Line: 481 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 486 to 491 in 819bd47

bool TestCase::checkLog (const string& against) {
return checkOutput(TestCase::clogBuffer.get()->str(),
against);
}
bool TestCase::checkStderr (const string& against) { 

!Line: 486 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 491 to 496 in 819bd47

bool TestCase::checkStderr (const string& against) {
return checkOutput(TestCase::stderrBuffer.get()->str(),
against);
}
bool TestCase::checkOutput (const string& source, const string& against) 

!Line: 491 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 496 to 501 in 819bd47

bool TestCase::checkOutput (const string& source, const string& against)
{
switch (this->option) {
case EXACT:
if (source == against) {
return true; 

!Line: 496 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 509 to 514 in 819bd47

if (this->clogOriginal.get() != nullptr) {
ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else { 

!Line: 509 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 510 to 515 in 819bd47

ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl; 

!Line: 510 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 511 to 516 in 819bd47

tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl;
} 

!Line: 511 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 515 to 520 in 819bd47

clog << nomatch.str() << endl;
}
return false;
} 

!Line: 515 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 531 to 536 in 819bd47

if (this->clogOriginal.get() != nullptr) {
ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else { 

!Line: 531 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 532 to 537 in 819bd47

ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl; 

!Line: 532 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 533 to 538 in 819bd47

tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl;
} 

!Line: 533 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 537 to 542 in 819bd47

clog << nomatch.str() << endl;
}
return false;
} 

!Line: 537 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 544 to 549 in 819bd47

stringstream re;
re << TCPPStr::UNK_CMP_OPT << this->option;
throw TestCPPException(re.str());
}
}
} 

!Line: 544 - error: variable name 're' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]



!Maximum character count per GitHub comment has been reached! Not all warnings/errors has been parsed!

eljonny added 3 commits March 5, 2025 18:53
@eljonny
A number of funcs/args are now const to fix part of #29
4a21d97 
I altered the functions referenced by cppcheck in TestCPPTestCase
 and TestCPPUtil so they are const; they shouldn't modify the state of
 the object.
@eljonny
Fix the remaining issues related to #29.
7d31469 
These were much simpler to resolve and also made a lot of sense to make
 const.
@eljonny
Remove issues list - all issues resolved.
819bd47
@eljonny eljonny merged commit 88a407d into main Mar 6, 2025
41 of 42 checks passed
@eljonny eljonny deleted the fix-cppcheck-performance-functionconst branch March 6, 2025 03:13
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

@eljonny eljonny

Labels

static-analysis An issue related to a static analysis result test-case Relating to TestCPP TestCase test-suite Relating to TestCPP TestSuite test-utils Related to TestCPP util functions and TestCPPUtil

Projects

None yet

Milestone

0.3-release

Development

Successfully merging this pull request may close these issues.

Fix CPPCheck Issues - Member function can be const

1 participant

@eljonny